home *** CD-ROM | disk | FTP | other *** search
/ The World of Computer Software / The World of Computer Software.iso / ultra250.zip / UW_HELP2.HLP < prev    next >
Text File  |  1992-11-03  |  24KB  |  766 lines
  1. `co(4,7);────────────────────────── /// Window I/O Routines ───────────────────────────`co();
  2.  ┌──────────────────────────────────────────────────────────────────────────┐    
  3.  │        `keyword(wn_plst,/// wn_plst);                `keyword(wn_printf,/// wn_printf);           `keyword(wn_st,/// wn_st);                  │
  4.  │        `keyword(wn_st_qty,/// wn_st_qty);              `keyword(wn_qch,/// wn_qch);              `keyword(wn_ch,/// wn_ch);                  │
  5.  │        `keyword(wn_och,/// wn_och);                 `keyword(wn_co,/// wn_co);               `keyword(wn_hline,/// wn_hline);               │
  6.  │        `keyword(wn_vline,/// wn_vline);               `keyword(wn_cleol,/// wn_cleol);            `keyword(wn_clbol,/// wn_clbol);               │     
  7.  │        `keyword(wn_claol,/// wn_claol);               `keyword(wn_cleos,/// wn_cleos);            `keyword(wn_clbos,/// wn_clbos);               │
  8.  │        `keyword(wn_claos,/// wn_claos);               `keyword(wn_cln,/// wn_cln);              `keyword(wn_ins_del_chars,/// wn_ins_del_chars);       │  
  9.  │        `keyword(wn_ins_del_lines,/// wn_ins_del_lines);       `keyword(wn_csr_dn,/// wn_csr_dn);           `keyword(wn_csr_up,/// wn_csr_up);              │
  10.  │        `keyword(wn_csr_left,/// wn_csr_left);            `keyword(wn_csr_right,/// wn_csr_right);        `keyword(wn_csr_pos,/// wn_csr_pos);             │
  11.  │        `keyword(wn_scroll_reg,/// wn_scroll_reg);          `keyword(wn_bksp,/// wn_bksp);                                    │
  12.  │        `keyword(wn_st_fmt,/// wn_st_fmt);                                                         │
  13.  └──────────────────────────────────────────────────────────────────────────┘
  14.  
  15.         These functions allow a great deal of flexibility for input/output to a
  16.     window. Included are string output routines, window "printf" capability,
  17.     multiple character output in both vertical and horizontal directions, line
  18.     drawing in a window with automatic blending of crossover points and border
  19.     intersection, clearing to the end of a line, beginning of line, end of
  20.     screen, and many others.  New for V2.5 is an output routine that will
  21.     process control characters such as bell, backspace, tabs, carriage returns
  22.     and line feeds.  It will even word wrap for you!  See `keyword(wn_st_fmt,/// wn_st_fmt);
  23.     for more details.
  24.  
  25. `co(10,1);/// wn_plst`co();   `keyword(source,[UW_ST.C]~wn_plst);
  26.         Outputs a string to a window starting at a specific row and column.
  27.  
  28. Prototype:
  29.     void wn_plst( int col, int line, char *s, WINDOW *wnp );
  30.  
  31. Parameters:
  32. `co(11,1);    int col, row`co();
  33.         The location of the window to begin output.  The column can also be set
  34.         to one of the three predefined values CENTERED, LEFT_JUST, and
  35.         RIGHT_JUST (defined in the file UW.H).
  36.  
  37. `co(11,1);    uchar *s`co();
  38.         A pointer to the characters to place in the window.
  39. `co(11,1);    WINDOW *wnp`co();
  40.         A pointer to the window in which the string is to be placed.
  41.  
  42. Usage:
  43.     wn_plst( 10, 20, "This string starts at x = 10, y = 20.", wnp );
  44.  
  45. `co(10,1);/// wn_printf`co();   `keyword(source,[UW_PRTF.C]~wn_printf);
  46.         Outputs formatted text to a window at the current window cursor
  47.     position. The formatted output takes the same format string as the printf
  48.     family of functions.
  49.  
  50. Prototype:
  51.     int wn_printf( WINDOW *wnp, char *fmt, ... );
  52.  
  53. Parameters:
  54. `co(11,1);    WINDOW *wnp`co();
  55.         The window in which to place the formatted output.
  56. `co(11,1);    char *fmt`co();
  57.         The format string, followed by any variables, strings, etc...
  58.  
  59. Usage:
  60.     WINDOW *wnp;
  61.     int x = 10;
  62.     float f = 3.14;
  63.     ...
  64.     wn_printf( wnp, "The value of x is %d, f is %4.2f", x, f );
  65.  
  66. `co(10,1);/// wn_st`co();   `keyword(source,[UW_ST.C]~wn_st);
  67.         Outputs the string at the current window cursor position.
  68.  
  69. Prototype:
  70.     void wn_st( char *s, WINDOW *wnp );
  71.  
  72. Parameters:
  73. `co(11,1);    uchar *s;`co();
  74.         The string to output to the window.
  75. `co(11,1);    WINDOW *wnp;`co();
  76.         The window in which the string will be placed.
  77.  
  78. Usage:
  79.     WINDOW *wnp;
  80.     ...
  81.     wn_st( "This line will print at the window cursor position", wnp );
  82.  
  83. `co(10,1);/// wn_st_qty`co();   `keyword(source,[UW_ST.C]~wn_st_qty);
  84.         Outputs a specific number of characters from a string to the window at
  85.     the current window position.  If the number to output is greater than the
  86.     string length, this function will output to the end of the string and
  87.     stop.
  88.  
  89. Prototype:
  90.     void wn_st_qty( char *s, int qty, WINDOW *wnp );
  91.  
  92. Parameters:
  93. `co(11,1);    uchar *s`co();
  94.         The string to output to the window.
  95. `co(11,1);    int qty`co();
  96.         The number of characters from the string to output.
  97. `co(11,1);    WINDOW *wnp`co();
  98.         A pointer to the window in which the output is to occur.
  99.  
  100. Usage:
  101.     WINDOW *wnp;
  102.     ...
  103.     wn_st_qty( "Only 20 chars of this will be output", 20, wnp );
  104.  
  105. `co(10,1);/// wn_qch`co();   `keyword(source,[UW_CH.C]~wn_qch);
  106.         Outputs a character to a window a repeated number of times.
  107.  
  108. Prototype:
  109.     void wn_qch( int cnt, uchar c, WINDOW *wnp );
  110.  
  111. Parameters:
  112. `co(11,1);    int cnt`co();
  113.         The number of times to output the character.
  114. `co(11,1);    uchar c`co();
  115.         The character to output to the window.
  116. `co(11,1);    WINDOW *wnp`co();
  117.         A pointer to the window in which the output is to occur.
  118.  
  119. Usage:
  120.     WINDOW *wnp;
  121.     ...
  122.     wn_qch( 20, '*', wnp );
  123.  
  124. `co(10,1);/// wn_ch`co();   `keyword(source,[UW_CH.C]~wn_ch);
  125.         Outputs one character at the current window cursor location.
  126.     
  127. Prototype:
  128.     void wn_ch( uchar c, WINDOW *wnp );
  129.  
  130. Parameters:
  131. `co(11,1);    uchar c`co();
  132.         The character to output to the window.
  133. `co(11,1);    WINDOW *wnp`co();
  134.         A pointer to the window in which the character is to be drawn.
  135.         
  136. Usage:
  137.     WINDOW *wnp;
  138.     ...
  139.     wn_ch( 'A', wnp );
  140.  
  141. `co(10,1);/// wn_och`co();   `keyword(source,[UW_CH.C]~wn_och);
  142.         Returns the character located at the window cursor location.
  143.     
  144. Prototype:
  145.     uchar wn_och( WINDOW *wnp );
  146.  
  147. Parameters:
  148. `co(11,1);    WINDOW *wnp`co();
  149.         A pointer to the window in which to retrieve the character.
  150.  
  151. Usage:
  152.     WINDOW *wnp;
  153.     uchar val;
  154.     ...
  155.     val = wn_och( wnp );
  156.  
  157. `co(10,1);/// wn_oatt`co();   `keyword(source,[UW_CH.C]~wn_oatt);
  158.         Returns the attribute located at the window cursor location.
  159.     
  160. Prototype:
  161.     uchar wn_oatt( WINDOW *wnp );
  162.  
  163. Parameters:
  164. `co(11,1);    WINDOW *wnp`co();
  165.         A pointer to the window in which to retrieve the attribute.
  166.  
  167. Usage:
  168.     WINDOW *wnp;
  169.     uchar val;
  170.     ...
  171.     val = wn_oatt( wnp );
  172.  
  173. `co(10,1);/// wn_co`co();   `keyword(source,[UW_BDR.C]~wn_co);
  174.         Writes a specific number of characters starting at the current window
  175.     cursor location and moving downward.    This is, in effect, a vertical
  176.     wn_qch routine.
  177.     
  178. Prototype:
  179.     void wn_co( int cnt, uchar c, WINDOW *wnp );
  180.  
  181. Parameters:
  182. `co(11,1);    int qty`co();
  183.         The number of times to output the character.
  184. `co(11,1);    uchar c`co();
  185.         The character to output to the window.
  186. `co(11,1);    WINDOW *wnp`co();
  187.         A pointer to the window in which to output the vertical string.
  188.  
  189. Usage:
  190.     WINDOW *wnp;
  191.     ...
  192.     wn_co( 10, '*', wnp );
  193.  
  194. `co(10,1);/// wn_hline`co();   `keyword(source,[UW_BDR.C]~wn_hline);
  195.         Draws a horizontal line across the window, blending any intersections
  196.     with other lines and points where the line meets the window's left and
  197.     right border.
  198.     
  199. Prototype:
  200.     void wn_hline( int row, int style, WINDOW *wnp );
  201.  
  202. Parameters:
  203. `co(11,1);    int row`co();
  204.         The row number to place the horizontal line.
  205. `co(11,1);    int style`co();
  206.         The style of the line, SGL_BDR or DBL_BDR.
  207. `co(11,1);    WINDOW *wnp`co();
  208.         The window pointer for output.
  209.  
  210. Usage:
  211.     WINDOW *wnp;
  212.     ...
  213.     wn_hline( 5, SGL_BDR, wnp );
  214.  
  215. `co(10,1);/// wn_vline`co();   `keyword(source,[UW_BDR.C]~wn_vline);
  216.         Draws a vertical line down the window, blending any intersections with
  217.     other lines and points where the line meets the window's bottom and top
  218.     border.
  219.     
  220. Prototype:
  221.     void wn_vline( int col, int style, WINDOW *wnp );
  222.  
  223. Parameters:
  224. `co(11,1);    int col`co();
  225.         The column number to place the vertical line.
  226. `co(11,1);    int style`co();
  227.         The style of the line, SGL_BDR or DBL_BDR.
  228. `co(11,1);    WINDOW *wnp`co();
  229.         The pointer to the window for output.
  230.  
  231. Usage:
  232.     WINDOW *wnp;
  233.     ...
  234.     wn_vline( 40, DBL_BDR, wnp );
  235.  
  236. `co(10,1);/// wn_cleol`co();   `keyword(source,[UW_TERM.C]~wn_cleol);
  237.         Clears from the current window cursor location to the end of the line.
  238.     
  239. Prototype:
  240.     void wn_cleol( WINDOW *wnp );
  241.  
  242. Parameters:
  243. `co(11,1);    WINDOW *wnp`co();
  244.         The window pointer in which the action is to take place.
  245.  
  246. Usage:
  247.     WINDOW *wnp;
  248.     ...
  249.     wn_cleol( wnp );
  250.  
  251. `co(10,1);/// wn_clbol`co();   `keyword(source,[UW_TERM.C]~wn_clbol);
  252.         Clears from the current window cursor location to the beginning of the
  253.     line.
  254.     
  255. Prototype:
  256.     void wn_clbol( WINDOW *wnp );
  257.  
  258. Parameters:
  259. `co(11,1);    WINDOW *wnp`co();
  260.         The window pointer in which the action is to take place.
  261.  
  262. Usage:
  263.     WINDOW *wnp;
  264.     ...
  265.     wn_clbol( wnp );
  266.  
  267. `co(10,1);/// wn_claol`co();   `keyword(source,[UW_TERM.C]~wn_claol);
  268.         Clears all of the line on which the window cursor currently resides.
  269.     
  270. Prototype:
  271.     void wn_claol( WINDOW *wnp );
  272.  
  273. Parameters:
  274. `co(11,1);    WINDOW *wnp`co();
  275.         The window pointer in which the action is to take place.
  276.  
  277. Usage:
  278.     WINDOW *wnp;
  279.     ...
  280.     wn_claol( wnp );
  281.  
  282. `co(10,1);/// wn_cleos`co();   `keyword(source,[UW_TERM.C]~wn_cleos);
  283.         Clears from the current window cursor location to the lower right corner
  284.     of the window (clears to the end of the window).
  285.     
  286. Prototype:
  287.     void wn_cleos( WINDOW *wnp );
  288.  
  289. Parameters:
  290. `co(11,1);    WINDOW *wnp`co();
  291.         The window pointer in which the action is to take place.
  292.  
  293. Usage:
  294.     WINDOW *wnp;
  295.     ...
  296.     wn_cleos( wnp );
  297.  
  298. `co(10,1);/// wn_clbos`co();   `keyword(source,[UW_TERM.C]~wn_clbos);
  299.         Clears from the current window cursor location to the upper left corner
  300.     of the window (clears to the beginning of the window).
  301.     
  302. Prototype:
  303.     void wn_clbos( WINDOW *wnp );
  304.  
  305. Parameters:
  306. `co(11,1);    WINDOW *wnp`co();
  307.         The window pointer in which the action is to take place.
  308.  
  309. Usage:
  310.     WINDOW *wnp;
  311.     ...
  312.     wn_clbos( wnp );
  313.  
  314. `co(10,1);/// wn_claos`co();   `keyword(source,[UW_TERM.C]~wn_claos);
  315.         Clears the entire window scrolling region, which by default is the
  316.     entire window.  See also wn_clear;
  317.     
  318. Prototype:
  319.     void wn_claos( WINDOW *wnp );
  320.  
  321. Parameters:
  322. `co(11,1);    WINDOW *wnp`co();
  323.         The window pointer in which the action is to take place.
  324.  
  325. Usage:
  326.     WINDOW *wnp;
  327.     ...
  328.     wn_claos( wnp );
  329.  
  330. `co(10,1);/// wn_cln`co();   `keyword(source,[UW_TERM.C]~wn_cln);
  331.         Clears a specific number of cells to the right of the current window
  332.     cursor location.
  333.         
  334. Prototype:
  335.     void wn_cln( int qty, WINDOW *wnp );
  336.  
  337. Parameters:
  338. `co(11,1);    int qty`co();
  339.         The number of cells to clear.
  340. `co(11,1);    WINDOW *wnp`co();
  341.         The window pointer in which the cells are to be cleared.
  342.  
  343. Usage:
  344.     WINDOW *wnp;
  345.     ...
  346.     wn_cln( 20, wnp );
  347.  
  348. `co(10,1);/// wn_ins_del_chars`co();   `keyword(source,[UW_TERM.C]~wn_ins_del_chars);
  349.         Inserts or deletes characters at the current window location.
  350.  
  351. Prototype:
  352.     void wn_ins_del_chars(int mode, char c, int cnt, WINDOW *wnp );
  353.  
  354. Parameters:
  355. `co(11,1);    int mode`co();
  356.         INSERT or DELETE (defined in uw.h).
  357. `co(11,1);    int c`co();
  358.         the character to output for each position (for INSERT mode).
  359. `co(11,1);    int cnt`co();
  360.         the number of characters to output.
  361. `co(11,1);    WINDOW *wnp`co();
  362.         The window pointer in which the characters are inserted/deleted.
  363.     
  364. Usage:
  365.     WINDOW *wnp;
  366.     ...
  367.     wn_ins_del_chars(INSERT, '*', 12, wnp );
  368.  
  369. `co(10,1);/// wn_ins_del_lines`co();   `keyword(source,[UW_TERM.C]~wn_ins_del_lines);
  370.         Inserts or deletes lines at the current window location.
  371.  
  372. Prototype:
  373.     void wn_ins_del_lines(int mode, char c, int cnt, WINDOW *wnp );
  374.  
  375. Parameters:
  376. `co(11,1);    int mode`co();
  377.         INSERT or DELETE (defined in uw.h).
  378. `co(11,1);    int c`co();
  379.         The character to output on inserted lines.
  380. `co(11,1);    int cnt`co();
  381.         The number of lines to insert or delete.
  382. `co(11,1);    WINDOW *wnp`co();
  383.         The window pointer in which the lines are inserted/deleted.
  384.  
  385. Usage:
  386.     WINDOW *wnp;
  387.     ...
  388.     wn_ins_del_lines(DELETE, ' ', 3, wnp );
  389.  
  390. `co(10,1);/// wn_csr_dn`co();   `keyword(source,[UW_TERM.C]~wn_csr_dn);
  391.         Moves the window cursor down "qty" lines.
  392.  
  393. Prototype:
  394.     void wn_csr_dn( int qty, WINDOW *wnp );
  395.  
  396. Parameters:
  397. `co(11,1);    int qty`co();
  398.         The number of lines to move down.
  399. `co(11,1);    WINDOW *wnp`co();
  400.         The window pointer in which the cursor will be moved.
  401.     
  402. Usage:
  403.     WINDOW *wnp;
  404.     ...
  405.     wn_csr_dn( 4, wnp );
  406.  
  407. `co(10,1);/// wn_csr_up`co();   `keyword(source,[UW_TERM.C]~wn_csr_up);
  408.         Moves the window cursor up "qty" lines.
  409.  
  410. Prototype:
  411.     void wn_csr_up( int qty, WINDOW *wnp );
  412.  
  413. Parameters:
  414. `co(11,1);    int qty`co();
  415.         The number of lines to move up.
  416. `co(11,1);    WINDOW *wnp`co();
  417.         The window pointer in which the cursor will be moved.
  418.     
  419. Usage:
  420.     WINDOW *wnp;
  421.     ...
  422.     wn_csr_up(4, wnp );
  423.  
  424. `co(10,1);/// wn_csr_left`co();   `keyword(source,[UW_TERM.C]~wn_csr_left);
  425.         Moves the window cursor left "qty" columns.
  426.  
  427. Prototype:
  428.     void wn_csr_left( int qty, WINDOW *wnp );
  429.  
  430. Parameters:
  431. `co(11,1);    int qty`co();
  432.         The number of columns to move left.
  433. `co(11,1);    WINDOW *wnp`co();
  434.         The window pointer in which the cursor will be moved.
  435.     
  436. Usage:
  437.     WINDOW *wnp;
  438.     ...
  439.     wn_csr_left( 2, wnp );
  440.  
  441. `co(10,1);/// wn_csr_right`co();   `keyword(source,[UW_TERM.C]~wn_csr_right);
  442.         Moves the window cursor right "qty" columns.
  443.  
  444. Prototype:
  445.     void wn_csr_right( int qty, WINDOW *wnp );
  446.  
  447. Parameters:
  448. `co(11,1);    int qty`co();
  449.         The number of columns to move right.
  450. `co(11,1);    WINDOW *wnp`co();
  451.         The window pointer in which the cursor will be moved.
  452.     
  453. Usage:
  454.     WINDOW *wnp;
  455.     ...
  456.     wn_csr_right( 3, wnp );
  457.  
  458. `co(10,1);/// wn_csr_pos`co();   `keyword(source,[UW_TERM.C]~wn_csr_pos);
  459.         Moves the window cursor to a certain position.
  460.  
  461. Prototype:
  462.     void wn_csr_pos( int line, int col, WINDOW *wnp );
  463.  
  464. Parameters:
  465. `co(11,1);    int line, col`co();
  466.         The line and column to move the cursor to.
  467. `co(11,1);    WINDOW *wnp`co();
  468.         The window pointer in which the cursor will be moved.
  469.     
  470. Usage:
  471.     WINDOW *wnp;
  472.     ...
  473.     wn_csr_pos( 4, 3, wnp );
  474.  
  475. `co(10,1);/// wn_scroll_reg`co();   `keyword(source,[UW_TERM.C]~wn_scroll_reg);
  476.         Sets a scrolling region within a window.
  477.  
  478. Prototype:
  479.     void wn_scroll_reg( int line_s, int line_e, WINDOW *wnp );
  480.  
  481. Parameters:
  482. `co(11,1);  int line_s, line_e`co();
  483.         The starting and ending lines for the scrolling region.
  484. `co(11,1);    WINDOW *wnp`co();
  485.         The window pointer in which the region is set.
  486.     
  487. Usage:
  488.     WINDOW *wnp;
  489.     ...
  490.     wn_scroll_reg( 3, 6, wnp );
  491.  
  492. `co(10,1);/// wn_bksp`co();   `keyword(source,[UW_TERM.C]~wn_bksp);
  493.         Backspaces "qty" positions.             
  494.  
  495. Prototype:
  496.     void wn_bksp( int qty, WINDOW *wnp );
  497.  
  498. Parameters:
  499. `co(11,1);    int qty`co();
  500.         The number of positions to backspace.
  501. `co(11,1);    WINDOW *wnp`co();
  502.         The window pointer in which the backspaces will occur.
  503.  
  504. Usage:
  505.     WINDOW *wnp;
  506.     ...
  507.     wn_bksp( 4, wnp );
  508.  
  509. `co(10,1);/// wn_st_fmt`co();   `keyword(source,[UW_ST.C]~wn_st_fmt);
  510.         Outputs the string at the current window cursor position, using control
  511.     bits set by the window macros described below. 
  512.   
  513.     `keyword(A) wn_set_bell_flag,[uw_help5.hlp]/// wn_set_bell_flag);    - turns on the processing of the bell character. 
  514.     `keyword(B) wn_set_bk_flag,[uw_help5.hlp]/// wn_set_bk_flag);      - turns on the processing of backspaces. 
  515.     `keyword(C) wn_set_cr_flag,[uw_help5.hlp]/// wn_set_cr_flag);      - turns on the processing of carriage returns. 
  516.     `keyword(D) wn_set_lf_flag,[uw_help5.hlp]/// wn_set_lf_flag);      - turns on the processing of line feeds. 
  517.     `keyword(E) wn_set_cr_lf_flag,[uw_help5.hlp]/// wn_set_cr_lf_flag);   - turns on the processing of both carriage
  518.                            returns and line feeds. 
  519.     `keyword(F) wn_set_tab_flag,[uw_help5.hlp]/// wn_set_tab_flag);     - turns on the processing of tabs. 
  520.     `keyword(G) wn_set_w_wrap,[uw_help5.hlp]/// wn_set_w_wrap);       - turns on word wrap. 
  521.     
  522.   NOTE: All of these bits default to ON when a window is created except
  523.   for cr_lf_flag.  This flag is mutually exclusive with the cr_flag and
  524.   lf_flag.  By default, a carriage return moves the cursor to the start
  525.   of the current line, and a line feed moves it down one line.  Therefore,
  526.   both a carriage return AND line feed are required to move to the start
  527.   of the next line.
  528.           
  529. Prototype:
  530.     void wn_st_fmt( char *s, WINDOW *wnp );
  531.  
  532. Parameters:
  533. `co(11,1);    uchar *s;`co();
  534.         The string to output to the window.
  535. `co(11,1);    WINDOW *wnp;`co();
  536.         The window in which the string will be placed.
  537.  
  538. Usage:
  539.     WINDOW *wnp;
  540.     ...
  541.     wn_st_fmt("This line will\r\nprint at tr\bhe window\007 cursor 
  542.                position and beep.", wnp);
  543.  
  544.     This line will
  545.     print at the window cursor position and beep.
  546.  
  547. `co(4,7);────────────────────────── /// Cursor Routines ───────────────────────────────`co();
  548.  
  549.  ┌──────────────────────────────────────────────────────────────────────────┐    
  550.  │            `keyword(rd_csr,/// rd_csr);               `keyword(mv_csr,/// mv_csr);            `keyword(csr_style,/// csr_style);              │
  551.  │            `keyword(csr_hide,/// csr_hide);             `keyword(csr_show,/// csr_show);          `keyword(pl_csr,/// pl_csr);                 │
  552.  └──────────────────────────────────────────────────────────────────────────┘
  553.     
  554.       These functions allow manipulation of the hardware cursor. The cursor
  555.     style, location, visibility, and window placement are all supported, along
  556.     with the ability to read its current location.
  557.  
  558. `co(10,1);/// rd_csr`co();   `keyword(source,[UW_CSR.C]~rd_csr);
  559.         Gets the current screen column and row where the hardware text cursor
  560.     currently resides.  The upper-left corner of the screen is defined as
  561.     (0,0).
  562.  
  563. Prototype:
  564.     void rd_csr( int *col, int *line );
  565.  
  566. Parameters:
  567. `co(11,1);    int *col, int *row`co();
  568.         Pointers to integers where the location is to be placed.  By passing the
  569.         address of an integer for each of these parameters, you can have this
  570.         function set their values for you.
  571.  
  572. Usage:
  573.     int column, row;
  574.     ...
  575.     rd_csr( &column, &row );
  576.  
  577. `co(10,1);/// mv_csr`co();   `keyword(source,[UW_CSR.C]~mv_csr);
  578.         Moves the hardware text cursor to the specified column and row.
  579.  
  580. Prototype:
  581.     void mv_csr( int col, int line );
  582.  
  583. Parameters:
  584. `co(11,1);    int col, int row`co();
  585.         Integers containing the new column and row values.
  586.  
  587. Usage:
  588.     mv_csr( 20, 10 );
  589.  
  590. `co(10,1);/// csr_style`co();   `keyword(source,[UW_CSR.C]~csr_style);
  591.         Changes the hardware text cursor to one of several forms.     The choices
  592.     are a "thin line" cursor, a "small block" cursor, and a "fat block"
  593.     cursor.
  594.  
  595. Prototype:
  596.     void csr_style( int style );
  597.  
  598. Parameters:
  599. `co(11,1);    int style`co();
  600.         A value used to specify the new hardware text cursor appearance. This
  601.         number can be one of the defined (uw.h) values C_LINE, C_SBLOCK, or
  602.         C_FBLOCK.
  603.  
  604. Usage:
  605.     csr_style(C_FBLOCK);
  606.  
  607. `co(10,1);/// csr_hide`co();   `keyword(source,[UW_CSR.C]~csr_hide);
  608.         Makes the hardware text cursor invisible by moving it off the visible
  609.     screen.
  610.  
  611. Prototype:
  612.     void csr_hide(void);
  613.  
  614. Parameters:
  615.     None.
  616.  
  617. Usage:
  618.     csr_hide();
  619.  
  620. `co(10,1);/// csr_show`co();   `keyword(source,[UW_CSR.C]~csr_show);
  621.         causes the hardware text cursor to appear at the location it existed
  622.     when csr_hide was called.
  623.  
  624. Prototype:
  625.     void csr_show(void);
  626.  
  627. Parameters:
  628.     None.
  629.  
  630. Usage:
  631.     csr_show();
  632.  
  633. `co(10,1);/// pl_csr`co();   `keyword(source,[UW_CSR.C]~pl_csr);
  634.         Places the hardware text cursor at the column and row of the "soft"
  635.     cursor position within a window.  This function allows you to track the
  636.     hardware cursor with the window cursor.  The window cursor is simply the
  637.     csr_x and csr_y members of the window structure, and is the place where
  638.     output is directed.  NOTE: To position the soft cursor within a window,
  639.     use the mv_cs macro.
  640.  
  641. Prototype:
  642.     void pl_csr( WINDOW *wnp );
  643.  
  644. Parameters:
  645. `co(11,1);    WINDOW *wnp`co();
  646.         A pointer to the window in which the hardware text cursor is to be
  647.         placed.
  648.  
  649. Usage:
  650.     WINDOW *wnp;
  651.     ...
  652.     pl_csr( wnp );
  653.  
  654. `co(4,7);────────────────────────── /// Tab Stop Control ──────────────────────────────`co();
  655.  
  656.  ┌──────────────────────────────────────────────────────────────────────────┐    
  657.  │        `keyword(wn_init_tabs,/// wn_init_tabs);         `keyword(wn_clear_tabs,/// wn_clear_tabs);         `keyword(wn_set_tab,/// wn_set_tab);             │
  658.  │        `keyword(wn_reset_tab,/// wn_reset_tab);         `keyword(wn_tab_right,/// wn_tab_right);          `keyword(wn_tab_left,/// wn_tab_left);            │
  659.  └──────────────────────────────────────────────────────────────────────────┘
  660.     
  661.     UltraWin supports full tab control.  Functions for setting global tab
  662.     stops, individual tab stops, clearing tab stops, and moving the window
  663.     cursor either left or right by tab are included.    These routines are very
  664.     useful when writing programs that use tabs, such as terminal emulators.
  665.  
  666. `co(10,1);/// wn_init_tabs`co();   `keyword(source,[UW_TERM.C]~wn_init_tabs);
  667.         Sets the window tab stops to a tab every nth position.  This gives you
  668.     the ability to set tab stops for a window with a single function call.
  669.  
  670. Prototype:
  671.     void wn_init_tabs( int space, WINDOW *wnp );
  672.  
  673. Parameters:
  674. `co(11,1);    int space`co();
  675.         A number that indicates the distance of one tab stop to another. For
  676.         example, a value of 10 would set tab stops at every 10th column, accross
  677.         the full width of the window.
  678. `co(11,1);    WINDOW *wnp`co();
  679.         A pointer to the window in which the tabs are to be set.
  680.  
  681. Usage:
  682.     WINDOW *wnp;
  683.     ...
  684.     wn_init_tabs( wnp );
  685.  
  686. `co(10,1);/// wn_clear_tabs`co();   `keyword(source,[UW_TERM.C]~wn_clear_tabs);
  687.         Clears all tab stops for a window.
  688.  
  689. Prototype:
  690.     void wn_clear_tabs( WINDOW *wnp );
  691.  
  692. Parameters:
  693. `co(11,1);    WINDOW *wnp`co();
  694.         The window for which to clear all tabs.
  695.  
  696. Usage:
  697.     WINDOW *wnp;
  698.     ...
  699.     wn_clear_tabs( wnp );
  700.  
  701. `co(10,1);/// wn_set_tab`co();   `keyword(source,[UW_TERM.C]~wn_set_tab);
  702.         Sets a tab at the current cursor column.
  703.  
  704. Prototype:
  705.     void wn_set_tab( WINDOW *wnp );
  706.  
  707. Parameters:
  708. `co(11,1);    WINDOW *wnp`co();
  709.         The window in which the tab is to be set.
  710.  
  711. Usage:
  712.     WINDOW *wnp;
  713.     ...
  714.     wn_set_tab( wnp );
  715.  
  716. `co(10,1);/// wn_reset_tab`co();   `keyword(source,[UW_TERM.C]~wn_reset_tab);
  717.         Resets the tab at the current cursor column.
  718.  
  719. Prototype:
  720.     void wn_reset_tab( WINDOW *wnp );
  721.  
  722. Parameters:
  723. `co(11,1);    WINDOW *wnp`co();
  724.         The window in which the tab is to be reset.
  725.  
  726. Usage:
  727.     WINDOW *wnp;
  728.     ...
  729.     wn_reset_tab( wnp );
  730.  
  731. `co(10,1);/// wn_tab_right`co();   `keyword(source,[UW_TERM.C]~wn_tab_right);
  732.         Moves from the current cursor column to the next tab stop.
  733.  
  734. Prototype:
  735.     void wn_tab_right( int cnt, WINDOW *wnp );
  736.  
  737. Parameters:
  738. `co(11,1);    int cnt`co();
  739.         The number of tabs to move right.
  740. `co(11,1);    WINDOW *wnp`co();
  741.         The window in which to tab right.
  742.  
  743. Usage:
  744.     WINDOW *wnp;
  745.     ...
  746.     wn_tab_right( 3, wnp );
  747.  
  748. `co(10,1);/// wn_tab_left`co();   `keyword(source,[UW_TERM.C]~wn_tab_left);
  749.         Moves from the current cursor column to the previous tab.
  750.  
  751. Prototype:
  752.     void wn_tab_left( int cnt, WINDOW *wnp );
  753.  
  754. Parameters:
  755. `co(11,1);    int cnt`co();
  756.         The number of tabs to move left.
  757. `co(11,1);    WINDOW *wnp`co();
  758.         The window in which to tab left.
  759.  
  760. Usage:
  761.     WINDOW *wnp;
  762.     ...
  763.     wn_tab_left( 3, wnp );
  764.  
  765.  
  766.